package com.tzy.parser.core.strategy;

import com.tzy.parser.core.AttributeParser;
import com.tzy.parser.core.Constant;
import com.tzy.parser.exception.MetaObjNameException;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.util.Stack;

public class ComputationTemplateStrategy implements TemplateStrategy {

    private AttributeParser parser;

    public ComputationTemplateStrategy(AttributeParser parser) {
        this.parser = parser;
    }

    @Override
    public String strategyName() {
        return "computation";
    }

    @Override
    public boolean canParse(String template) {
        return Constant.isComputationOperations(template);
    }

    @Override
    public Object parse(String template, Object meta) {

        if (template == null) {
            return null;
        }

        template = template.trim();

        return evaluateExpression(template, meta);
    }


    //这个函数的作用就是使用空格分割字符串，以便后面使用分割函数使得将字符串分割成数组
    public String insetBlanks(String s) {
        String result = "";
        for (int i = 0; i < s.length(); i++) {
            if (s.charAt(i) == '(' || s.charAt(i) == ')' ||
                    s.charAt(i) == Constant.ADD || s.charAt(i) == Constant.SUB
                    || s.charAt(i) == Constant.MUL || s.charAt(i) == Constant.DIV)
                result += " " + s.charAt(i) + " ";
            else
                result += s.charAt(i);
        }
        return result;
    }

    public double evaluateExpression(String expression, Object meta) {
        Stack<BigDecimal> operandStack = new Stack<>();
        Stack<Character> operatorStack = new Stack<>();
        expression = insetBlanks(expression);
        String[] tokens = expression.split(" ");
        for (String token : tokens) {
            if (token.length() == 0)   //如果是空格的话就继续循环，什么也不操作
                continue;
                //如果是加减的话，因为加减的优先级最低，因此这里的只要遇到加减号，无论操作符栈中的是什么运算符都要运算
            else if (token.charAt(0) == Constant.ADD || token.charAt(0) == Constant.SUB) {
                //当栈不是空的，并且栈中最上面的一个元素是加减乘除的人任意一个
                while (!operatorStack.isEmpty() && (operatorStack.peek() == Constant.SUB || operatorStack.peek() == Constant.ADD || operatorStack.peek() == Constant.DIV || operatorStack.peek() == Constant.MUL)) {
                    processAnOperator(operandStack, operatorStack);   //开始运算
                }
                operatorStack.push(token.charAt(0));   //运算完之后将当前的运算符入栈
            }
            //当前运算符是乘除的时候，因为优先级高于加减，因此要判断最上面的是否是乘除，如果是乘除就运算，否则的话直接入栈
            else if (token.charAt(0) == Constant.MUL || token.charAt(0) == Constant.DIV) {
                while (!operatorStack.isEmpty() && (operatorStack.peek() == Constant.DIV || operatorStack.peek() == Constant.MUL)) {
                    processAnOperator(operandStack, operatorStack);
                }
                operatorStack.push(token.charAt(0));   //将当前操作符入栈
            }
            //如果是左括号的话直接入栈，什么也不用操作,trim()函数是用来去除空格的，由于上面的分割操作可能会令操作符带有空格
            else if (token.trim().charAt(0) == '(') {
                operatorStack.push('(');
            }
            //如果是右括号的话，清除栈中的运算符直至左括号
            else if (token.trim().charAt(0) == ')') {
                while (operatorStack.peek() != '(') {
                    processAnOperator(operandStack, operatorStack);    //开始运算
                }
                operatorStack.pop();   //这里的是运算完之后清除左括号
            }
            //这里如果是数字的话直接如数据的栈
            else {

                Object o = parser.baseParse(meta, token);
                if (o instanceof BigDecimal) {
                    //将数字字符串转换成数字然后压入栈中
                    operandStack.push((BigDecimal) o);
                } else {
                    try {
                        operandStack.push(new BigDecimal(o.toString()));
                    } catch (Exception e) {
                        throw new MetaObjNameException(o.toString() + "无法转换 计算\n"+e.getMessage());
                    }


                }


            }
        }
        //最后当栈中不是空的时候继续运算，知道栈中为空即可
        while (!operatorStack.isEmpty()) {
            processAnOperator(operandStack, operatorStack);
        }
        return operandStack.pop().doubleValue();    //此时数据栈中的数据就是运算的结果
    }

    //这个函数的作用就是处理栈中的两个数据，然后将栈中的两个数据运算之后将结果存储在栈中
    public void processAnOperator(Stack<BigDecimal> operandStack, Stack<Character> operatorStack) {
        char op = operatorStack.pop();  //弹出一个操作符
        BigDecimal op1 = operandStack.pop();  //从存储数据的栈中弹出连个两个数用来和操作符op运算
        BigDecimal op2 = operandStack.pop();
        if (op == Constant.ADD)  //如果操作符为+就执行加运算
            operandStack.push(op1.add(op2));
        else if (op == Constant.SUB)
            operandStack.push(op2.subtract(op1));   //因为这个是栈的结构，自然是上面的数字是后面的，因此用op2-op1
        else if (op == Constant.MUL)
            operandStack.push(op1.multiply(op2));
        else if (op == Constant.DIV)
            operandStack.push(op2.divide(op1,6, RoundingMode.HALF_UP));
    }

}
